Quantum vs. Classical Read-once Branching Programs

The paper presents the first nontrivial upper and lower bounds for (non-oblivious) quantum read-once branching programs. It is shown that the computational power of quantum and classical read-once branching programs is incomparable in the following sense: (i) A simple, explicit boolean function on 2n input bits is presented that is computable by error-free quantum read-once branching programs of size O(n^3), while each classical randomized read-once branching program and each quantum OBDD for this function with bounded two-sided error requires size 2^{\Omega(n)}. (ii) Quantum branching programs reading each input variable exactly once are shown to require size 2^{\Omega(n)} for computing the set-disjointness function DISJ_n from communication complexity theory with two-sided error bounded by a constant smaller than 1/2-2\sqrt{3}/7. This function is trivially computable even by deterministic OBDDs of linear size. The technically most involved part is the proof of the lower bound in (ii). For this, a new model of quantum multi-partition communication protocols is introduced and a suitable extension of the information cost technique of Jain, Radhakrishnan, and Sen (2003) to this model is presented.Comment: 35 pages. Lower bound for disjointness: Error in application of info theory corrected and regularity of quantum read-once BPs (each variable at least once) added as additional assumption of the theorem. Some more informal explanations adde

Quantum Branching Programs and Space-Bounded Nonuniform Quantum Complexity

In this paper, the space complexity of nonuniform quantum computations is investigated. The model chosen for this are quantum branching programs, which provide a graphic description of sequential quantum algorithms. In the first part of the paper, simulations between quantum branching programs and nonuniform quantum Turing machines are presented which allow to transfer lower and upper bound results between the two models. In the second part of the paper, different variants of quantum OBDDs are compared with their deterministic and randomized counterparts. In the third part, quantum branching programs are considered where the performed unitary operation may depend on the result of a previous measurement. For this model a simulation of randomized OBDDs and exponential lower bounds are presented.Comment: 45 pages, 3 Postscript figures. Proofs rearranged, typos correcte

On Computational Power of Quantum Read-Once Branching Programs

In this paper we review our current results concerning the computational power of quantum read-once branching programs. First of all, based on the circuit presentation of quantum branching programs and our variant of quantum fingerprinting technique, we show that any Boolean function with linear polynomial presentation can be computed by a quantum read-once branching program using a relatively small (usually logarithmic in the size of input) number of qubits. Then we show that the described class of Boolean functions is closed under the polynomial projections.Comment: In Proceedings HPC 2010, arXiv:1103.226

An Improved Hierarchy Result for Partitioned BDDs

One of the great challenges of complexity theory is the problem of analyzing the dependence of the complexity of Boolean functions on the resources nondeterminism and randomness. So far, this problem could be solved only for very few models of computation. For so-called partitioned binary decision diagrams, which are a restricted variant of nondeterministic read-once branching programs, Bollig and Wegener have proven an astonishing hierarchy result which shows that the smallest possible decrease of the available amount of nondeterminism may incur an exponential blow-up of the branching program size. They have shown that k-partitioned BDDs which may nondeterministically choose between k alternative subprograms may be exponentially larger than (k + 1)-partitioned BDDs for the same function if k = o # (log n/ loglog n) 1/2 # , where n is the input size. In this paper, an improved hierarchy result is established which still works if the number of nondeterministic decisions is O ..

An asymptotically optimal lower bound on the OBDD size of the middle bit of multiplication for the pairwise ascending variable order

AbstractWe prove that each OBDD (ordered binary decision diagram) for the middle bit of n-bit integer multiplication for one of the variable orders which so far achieve the smallest OBDD sizes with respect to asymptotic order of growth, namely the pairwise ascending order x0,y0,…,xn−1,yn−1, requires a size of Ω(2(6/5)n). This is asymptotically optimal due to a bound of the same order by Amano and Maruoka (2007) [1]

Classical vs. Quantum Read-Once Branching Programs

Abstract. A simple, explicit boolean function on 2n input bits is presented that is computable by errorfree quantum read-once branching programs of size O(n 3), while each classical randomized read-once branching program and each quantum OBDD for this function with bounded twosided error requires size 2 Ω(n)

On the Size of Randomized OBDDs and Read-Once Branching Programs for k-Stable Functions

In this paper, a simple technique which unifies the known approaches for proving lower bound results on the size of deterministic, nondeterministic, and randomized OBDDs and kOBDDs is described

Guess-and-verify versus unrestricted nondeterminism for OBDDs and one-way Turing machines

AbstractIt is well known that a nondeterministic Turing machine can be simulated in polynomial time by a so-called guess-and-verify machine. It is an open question whether an analogous simulation exists in the context of space-bounded computation. In this paper, a negative answer to this question is given for ordered binary decision diagrams (OBDDs) and one-way Turing machines. If it is required that all nondeterministic guesses occur at the beginning of the computation, this can blow up the space complexity exponentially in the input length for these models. This is a consequence of the following main result of the paper. There is a sequence of boolean functions fn:{0,1}n→{0,1} such that fn has nondeterministic OBDDs of polynomial size that use at most (1/3)·(n/3)1/3logn·(1+o(1)) nondeterministic guesses for each computation, but fn already requires exponential size if only at most (1−ε)·(1/3)·(n/3)1/3logn nondeterministic guesses may be used, where ε>0 is an arbitrarily small constant

Lower Bounds for Randomized Read-k-Times Branching Programs (Extended Abstract)

) Martin Sauerhoff ? Fachbereich Informatik, Universitat Dortmund, 44221 Dortmund, Germany e-Mail: [email protected] Abstract. Randomized branching programs are a probabilistic model of computation defined in analogy to the well-known probabilistic Turing machines. In this paper, we contribute to the complexity theory of randomized read-k-times branching programs. We first consider the case k = 1 and present a function which has nondeterministic read-once branching programs of polynomial size, but for which every randomized read-once branching program with two-sided error at most 27=128 is exponentially large. The same function also exhibits an exponential gap between the randomized read-once branching program sizes for different constant worstcase errors, which shows that there is no "probability amplification" technique for read-once branching programs which allows to decrease the error to an arbitrarily small constant by iterating probabilistic computation..

Approximation of Boolean Functions by Combinatorial Rectangles

This paper deals with the number of monochromatic combinatorial rectangles required to approximate a Boolean function on a constant fraction of all inputs, where each rectangle may be defined with respect to its own partition of the input variables. The main result of the paper is that the number of rectangles required for the approximation of Boolean functions in this model is very sensitive to the allowed error: There is an explicitly defined sequence of functions f n : {0, 1} n # {0, 1} such that f n has rectangle approximations with a constant number of rectangles and one-sided error 1/3+o(1) or two-sided error 1/4+2 -#(n) , but, on the other hand, f n requires exponentially many rectangles if the error bounds are decreased by an arbitrarily small constant. Rectangle partitions and rectangle approximations with the same partition of the input variables for all rectangles have been thoroughly investigated in communication complexity theory. The complexity measures where each r..